Sügav sukeldumine Python NumPy juhuslikku valimisse: statistiliste jaotuste valdamine

Andmeteaduse ja arvutuste laias universumis ei ole juhuslike arvude genereerimise võime lihtsalt funktsioon; see on nurgakivi. Alates keerukate finantsmudelite ja teaduslike nähtuste simuleerimisest kuni masinõppe algoritmide treenimise ja tugevate statistiliste testide läbiviimiseni on kontrollitud juhuslikkus mootor, mis juhib arusaamist ja innovatsiooni. Selle võimekuse keskmes Pythoni ökosüsteemis on NumPy, teadusliku arvutamise põhiline pakett.

Kuigi paljud arendajad on tuttavad Pythoni sisseehitatud `random` mooduliga, on NumPy juhusliku valimi funktsioon võimas, pakkudes suurepärast jõudlust, laiemat valikut statistilisi jaotusi ja funktsioone, mis on loodud andmeanalüüsi rangete nõuete jaoks. See juhend viib teid sügavale sukeldumisele NumPy `numpy.random` moodulisse, liikudes põhiprintsiipidest kuni mitmesuguste oluliste statistiliste jaotuste valimi võtmise kunsti valdamiseni.

Miks on juhuslik valimine andmepõhises maailmas oluline

Enne koodi juurde asumist on oluline mõista, miks see teema on nii kriitiline. Juhuslik valimine on protsess, mille käigus valitakse statistilisest populatsioonist indiviidide alamhulk, et hinnata kogu populatsiooni omadusi. Arvutuslikus kontekstis on see andmete genereerimine, mis jäljendavad teatud reaalse maailma protsessi. Siin on mõned peamised valdkonnad, kus see on asendamatu:

• Simulatsioon: Kui analüütiline lahendus on liiga keeruline, saame simuleerida protsessi tuhandeid või miljoneid kordi, et mõista selle käitumist. See on Monte Carlo meetodite alus, mida kasutatakse valdkondades füüsikast rahanduseni.
• Masinõpe: Juhuslikkus on ülioluline mudeli kaalude initsialiseerimiseks, andmete jagamiseks treening- ja testkomplektideks, sünteetiliste andmete loomiseks väikeste andmekogumite suurendamiseks ja algoritmides nagu Juhuslikud Metsad.
• Statistiline järeldus: Tehnoloogiad nagu bootstrapping ja permutatsioonitestid sõltuvad juhuslikust valimisest, et hinnata hinnangute ebakindlust ja testida hüpoteese ilma tugevate eeldusteta andmete alusjaotuse kohta.
• A/B testimine: Kasutajate käitumise simuleerimine erinevates stsenaariumides võib aidata ettevõtetel hinnata muudatuse potentsiaalset mõju ja määrata vajalik valimi suurus reaalajas eksperimendi jaoks.

NumPy pakub tööriistu nende ülesannete tõhusaks ja täpselt täitmiseks, muutes selle oluliseks oskuseks igale andmespetsialistile.

Juhuslikkuse tuum NumPys: `Generator`

Kaasaegne viis juhuslike arvude genereerimise käsitlemiseks NumPys (alates versioonist 1.17) on `numpy.random.Generator` klassi kaudu. See on oluline täiustus vanemate, pärandmeetoditega võrreldes. Alustamiseks loote esmalt `Generator` eksemplari.

Standardne praktika on kasutada `numpy.random.default_rng()`:

            import numpy as np

# Loo vaikimisi juhuslike arvude generaatori (RNG) eksemplar
rng = np.random.default_rng()

# Nüüd saate seda 'rng' objekti kasutada juhuslike arvude genereerimiseks
juhuslik_float = rng.random()
print(f"Juhuslik ujukomaarv: {juhuslik_float}")
            

              
                Copy
              
            
          

Vana vs. Uus: `np.random.RandomState` vs. `np.random.Generator`

Võite näha vanemat koodi, mis kasutab funktsioone otse `np.random`-ist, nagu `np.random.rand()` või `np.random.randint()`. Need funktsioonid kasutavad globaalset, pärand `RandomState` eksemplari. Kuigi need töötavad endiselt tagasiühilduvuse jaoks, on kaasaegne `Generator` lähenemisviis eelistatud mitmel põhjusel:

• Parem statistiline omadus: Uus `Generator` kasutab kaasaegsemat ja jõulisemat pseudojuhuslike arvude genereerimise algoritmi (PCG64), millel on paremad statistilised omadused kui vanemal Mersenne Twisteril (MT19937), mida kasutab `RandomState`.
• Globaalset olekut pole: Selgesõnalise `Generator` objekti (`rng` meie näites) kasutamine väldib tuginemist varjatud globaalsele olekule. See muudab teie koodi modulaarsemaks, ennustatavamaks ja hõlpsamini silutavaks, eriti keerukates rakendustes või teekides.
• Jõudlus ja API: `Generator` API on puhtam ja sageli parema jõudlusega.

Parim praktika: Kõigi uute projektide puhul alustage alati generaatori eksemplari loomisega `rng = np.random.default_rng()`.

Reproduktiivsuse tagamine: seemne jõud

Arvutid ei genereeri tõeliselt juhuslikke arve; nad genereerivad pseudojuhuslikke arve. Need luuakse algoritmi abil, mis genereerib arvude jada, mis näib olevat juhuslik, kuid on tegelikult täielikult määratud algväärtusega, mida nimetatakse seemneks.

See on fantastiline funktsioon teaduse ja arenduse jaoks. Andes generaatorile sama seemne, saate tagada, et saate iga kord, kui oma koodi käivitate, täpselt sama "juhuslike" arvude jada. See on ülioluline järgmiste asjade jaoks:

• Reproduktiivne uurimistöö: Igaüks saab teie tulemusi täpselt korrata.
• Silumine: Kui viga ilmneb konkreetse juhusliku väärtuse tõttu, saate seda järjepidevalt reprodutseerida.
• Õiglased võrdlused: Erinevate mudelite võrdlemisel saate tagada, et neid treenitakse ja testitakse samadel juhuslikel andmejaotustel.

Siin on, kuidas seemet määrata:

            # Loo generaator konkreetse seemnega
rng_seeded = np.random.default_rng(seed=42)

# See genereerib alati samad esimesed 5 juhuslikku arvu
print("Esimene käivitus:", rng_seeded.random(5))

# Kui loome teise generaatori sama seemnega, saame sama tulemuse
rng_seeded_again = np.random.default_rng(seed=42)
print("Teine käivitus:", rng_seeded_again.random(5))
            

              
                Copy
              
            
          

Põhitõed: lihtsad viisid juhuslike andmete genereerimiseks

Enne keerukatesse jaotustesse sukeldumist käsitleme põhilisi ehitusplokke, mis on saadaval `Generator` objektil.

Juhuslikud ujukomaarvud: `random()`

Meetod `rng.random()` genereerib juhuslikke ujukomaarve poolavatud intervallis `[0.0, 1.0)`. See tähendab, et 0.0 on võimalik väärtus, kuid 1.0 mitte.

            # Genereeri üks juhuslik ujukomaarv
float_val = rng.random()
print(f"Üksik ujukomaarv: {float_val}")

# Genereeri 5 juhusliku ujukomaarvu 1D massiiv
float_array = rng.random(size=5)
print(f"1D massiiv: {float_array}")

# Genereeri 2x3 juhuslike ujukomaarvude maatriks
float_matrix = rng.random(size=(2, 3))
print(f"2x3 maatriks:\n{float_matrix}")
            

              
                Copy
              
            
          

Juhuslikud täisarvud: `integers()`

Meetod `rng.integers()` on mitmekülgne viis juhuslike täisarvude genereerimiseks. See võtab vahemiku määratlemiseks argumendid `low` ja `high`. Vahemik sisaldab `low` ja välistab `high`.

            # Genereeri üks juhuslik täisarv vahemikus 0 (kaasa arvatud) kuni 10 (välja arvatud)
int_val = rng.integers(low=0, high=10)
print(f"Üksik täisarv: {int_val}")

# Genereeri 5 juhusliku täisarvu 1D massiiv vahemikus 50 kuni 100
int_array = rng.integers(low=50, high=100, size=5)
print(f"Täisarvude 1D massiiv: {int_array}")

# Kui antakse ainult üks argument, käsitletakse seda kui 'high' väärtust (low=0)
# Genereeri 4 täisarvu vahemikus 0 kuni 5
int_array_simple = rng.integers(5, size=4)
print(f"Lihtsam süntaks: {int_array_simple}")
            

              
                Copy
              
            
          

Valimine oma andmetest: `choice()`

Sageli ei soovi te arve nullist genereerida, vaid pigem valida olemasolevast andmekogumist või loendist. Meetod `rng.choice()` on selleks ideaalne.

            # Määratle meie populatsioon
options = ["õun", "banaan", "kirss", "datel", "leeder"]

# Vali üks juhuslik valik
single_choice = rng.choice(options)
print(f"Üksik valik: {single_choice}")

# Vali 3 juhuslikku valikut (vaikimisi asendusvalimiga)
multiple_choices = rng.choice(options, size=3)
print(f"Mitu valikut (asendusega): {multiple_choices}")

# Vali 3 unikaalset valikut (valim ilma asenduseta)
# Märkus: suurus ei saa olla suurem kui populatsiooni suurus
unique_choices = rng.choice(options, size=3, replace=False)
print(f"Unikaalsed valikud (ilma asenduseta): {unique_choices}")

# Saate määrata ka tõenäosused igale valikule
probabilities = [0.1, 0.1, 0.6, 0.1, 0.1] # 'kirss' on palju tõenäolisem
weighted_choice = rng.choice(options, p=probabilities)
print(f"Kaalutud valik: {weighted_choice}")
            

              
                Copy
              
            
          

Peamiste statistiliste jaotuste uurimine NumPys

Nüüd jõuame NumPy juhusliku valimi võimsuse tuumani: võime võtta valimeid paljudest statistilistest jaotustest. Nende jaotuste mõistmine on oluline meid ümbritseva maailma modelleerimiseks. Käsitleme kõige tavalisemaid ja kasulikumaid.

Ühtlane jaotus: iga tulemus on võrdne

Mis see on: Ühtlane jaotus on kõige lihtsam. See kirjeldab olukorda, kus iga võimalik tulemus pidevas vahemikus on võrdselt tõenäoline. Mõelge idealiseeritud spinnerile, millel on võrdne võimalus maanduda mis tahes nurga all.

Millal seda kasutada: Seda kasutatakse sageli lähtepunktina, kui teil pole eelnevaid teadmisi, mis eelistaksid ühte tulemust teisele. See on ka alus, millest sageli genereeritakse teisi, keerukamaid jaotusi.

NumPy funktsioon: `rng.uniform(low=0.0, high=1.0, size=None)`

            # Genereeri 10 000 juhuslikku arvu ühtlasest jaotusest vahemikus -10 kuni 10
uniform_data = rng.uniform(low=-10, high=10, size=10000)

# Selle andmete histogramm peaks olema ligikaudu lame
import matplotlib.pyplot as plt

plt.hist(uniform_data, bins=50, density=True)
plt.title("Ühtlane jaotus")
plt.xlabel("Väärtus")
plt.ylabel("Tõenäosustihedus")
plt.show()
            

              
                Copy
              
            
          

Normaaljaotus (Gaussi jaotus): kellakõver

Mis see on: Võib-olla kõige olulisem jaotus kogu statistikas. Normaaljaotust iseloomustab selle sümmeetriline, kellakujuline kõver. Paljud looduslikud nähtused, nagu inimeste pikkus, mõõtmisvead ja vererõhk, kipuvad Keskse Piirteoreemi tõttu järgima seda jaotust.

Millal seda kasutada: Kasutage seda mis tahes protsessi modelleerimiseks, kus te eeldate, et väärtused koonduvad keskmise keskele, kusjuures äärmuslikud väärtused on haruldased.

NumPy funktsioon: `rng.normal(loc=0.0, scale=1.0, size=None)`

• `loc`: Jaotuse keskmine ("keskus").
• `scale`: Standardhälve (kui hajutatud on jaotus).

            # Simuleeri täiskasvanute pikkusi 10 000 inimese populatsiooni jaoks
# Eeldame keskmist pikkust 175 cm ja standardhälvet 10 cm
heights = rng.normal(loc=175, scale=10, size=10000)

plt.hist(heights, bins=50, density=True)
plt.title("Simuleeritud pikkuste normaaljaotus")
plt.xlabel("Pikkus (cm)")
plt.ylabel("Tõenäosustihedus")
plt.show()
            

              
                Copy
              
            
          

Eriline juhtum on Standardne normaaljaotus, mille keskmine on 0 ja standardhälve 1. NumPy pakub selle jaoks mugavat otseteed: `rng.standard_normal(size=None)`.

Binoomjaotus: seeria "Jah/Ei" katseid

Mis see on: Binoomjaotus modelleerib "edu" arvu fikseeritud arvus sõltumatutes katsetes, kus igal katsel on ainult kaks võimalikku tulemust (nt edu/ebaõnnestumine, pea/kiri, jah/ei).

Millal seda kasutada: Stsenaariumide modelleerimiseks, nagu peade arv 10 mündiviskamisel, defektsete esemete arv 50 esemest koosnevas partiis või klientide arv, kes klõpsavad reklaamil 100 vaatajast.

NumPy funktsioon: `rng.binomial(n, p, size=None)`

• `n`: Katsete arv.
• `p`: Edu tõenäosus ühes katses.

            # Simuleeri õiglase mündi (p=0.5) 20 korda (n=20) viskamist
# ja korda seda eksperimenti 1000 korda (size=1000)
# Tulemuseks on 1000 arvust koosnev massiiv, millest igaüks esindab peade arvu 20 viskamisel.
num_heads = rng.binomial(n=20, p=0.5, size=1000)

plt.hist(num_heads, bins=range(0, 21), align='left', rwidth=0.8, density=True)
plt.title("Binoomjaotus: peade arv 20 mündiviskamisel")
plt.xlabel("Peade arv")
plt.ylabel("Tõenäosus")
plt.xticks(range(0, 21, 2))
plt.show()
            

              
                Copy
              
            
          

Poissoni jaotus: sündmuste loendamine ajas või ruumis

Mis see on: Poissoni jaotus modelleerib sündmuse esinemiste arvu määratud aja- või ruumiintervallis, eeldusel, et need sündmused toimuvad teadaoleva konstantse keskmise kiirusega ja on sõltumatud ajast alates viimase sündmuseni.

Millal seda kasutada: Klientide saabumise arvu modelleerimiseks poodi tunnis, trükivigade arvu lehel või kõnekeskuse poolt minutis vastu võetud kõnede arvu.

NumPy funktsioon: `rng.poisson(lam=1.0, size=None)`

• `lam` (lambda): Sündmuste keskmine määr intervalli kohta.

            # Kohvikusse saabub keskmiselt 15 klienti tunnis (lam=15)
# Simuleeri iga tunni saabuvate klientide arvu 1000 tunni jooksul
customer_arrivals = rng.poisson(lam=15, size=1000)

plt.hist(customer_arrivals, bins=range(0, 40), align='left', rwidth=0.8, density=True)
plt.title("Poissoni jaotus: klientide saabumine tunnis")
plt.xlabel("Klientide arv")
plt.ylabel("Tõenäosus")
plt.show()
            

              
                Copy
              
            
          

Eksponentsiaalne jaotus: aeg sündmuste vahel

Mis see on: Eksponentsiaalne jaotus on tihedalt seotud Poissoni jaotusega. Kui sündmused toimuvad vastavalt Poissoni protsessile, siis aeg vahel järjestikuste sündmuste vahel järgib eksponentsiaalset jaotust.

Millal seda kasutada: Kuni järgmise kliendi saabumiseni kuluva aja modelleerimiseks, lambipirni eluea või aja kuni järgmise radioaktiivse lagunemiseni.

NumPy funktsioon: `rng.exponential(scale=1.0, size=None)`

• `scale`: See on Poissoni jaotuse kiirusparameetri (lambda) pöördväärtus. `scale = 1 / lam`. Seega, kui kiirus on 15 klienti tunnis, on keskmine aeg klientide vahel 1/15 tundi.

            # Kui kohvikusse saabub 15 klienti tunnis, on skaala 1/15 tundi
# Teisendame selle minutiteks: (1/15) * 60 = 4 minutit keskmiselt klientide vahel
scale_minutes = 4
time_between_arrivals = rng.exponential(scale=scale_minutes, size=1000)

plt.hist(time_between_arrivals, bins=50, density=True)
plt.title("Eksponentsiaalne jaotus: aeg klientide saabumiste vahel")
plt.xlabel("Minutid")
plt.ylabel("Tõenäosustihedus")
plt.show()
            

              
                Copy
              
            
          

Lognormaalne jaotus: kui logaritm on normaalne

Mis see on: Lognormaalne jaotus on pidev tõenäosusjaotus juhuslikule muutujale, mille logaritm on normaalselt jaotunud. Saadud kõver on parempoolselt asümmeetriline, mis tähendab, et sellel on pikk saba paremale.

Millal seda kasutada: See jaotus sobib suurepäraselt selliste koguste modelleerimiseks, mis on alati positiivsed ja mille väärtused hõlmavad mitut suurusjärku. Levinud näited on isiklik sissetulek, aktsiahinnad ja linnade populatsioonid.

NumPy funktsioon: `rng.lognormal(mean=0.0, sigma=1.0, size=None)`

• `mean`: Aluseks oleva normaaljaotuse keskmine (mitte lognormaalse väljundi keskmine).
• `sigma`: Aluseks oleva normaaljaotuse standardhälve.

            # Simuleeri sissetulekute jaotust, mis on sageli lognormaalselt jaotunud
# Need parameetrid on aluseks oleva log skaala jaoks
income_data = rng.lognormal(mean=np.log(50000), sigma=0.5, size=10000)

plt.hist(income_data, bins=100, density=True, range=(0, 200000)) # Piira vahemikku parema visualiseerimise jaoks
plt.title("Lognormaalne jaotus: simuleeritud aastased sissetulekud")
plt.xlabel("Sissetulek")
plt.ylabel("Tõenäosustihedus")
plt.show()
            

              
                Copy
              
            
          

Praktilised rakendused andmeteaduses ja mujal

Nende andmete genereerimise mõistmine on ainult pool võitu. Tõeline jõud tuleb selle rakendamisel.

Simulatsioon ja modelleerimine: Monte Carlo meetodid

Kujutage ette, et soovite hinnata Pi väärtust. Saate seda teha juhusliku valimiga! Idee on kirjutada ring ruudu sisse. Seejärel genereerige ruudu sees tuhandeid juhuslikke punkte. Ringi sisse langevate punktide suhe punktide koguarvu on proportsionaalne ringi pindala suhtega ruudu pindalasse, mida saab kasutada Pi lahendamiseks.

See on lihtne näide Monte Carlo meetodist: juhusliku valimi kasutamine deterministlike probleemide lahendamiseks. Reaalmaailmas kasutatakse seda finantsportfelli riski, osakeste füüsika ja keerukate projektiajakavade modelleerimiseks.

Masinõppe alused

Masinõppes on kontrollitud juhuslikkus kõikjal:

• Kaalu initsialiseerimine: Neuraalvõrgu kaalud initsialiseeritakse tavaliselt väikeste juhuslike arvudega, mis on saadud normaal- või ühtlasest jaotusest, et murda sümmeetriat ja võimaldada võrgul õppida.
• Andmete suurendamine: Pildituvastuse jaoks saate luua uusi treeningandmeid, rakendades olemasolevatele piltidele väikeseid juhuslikke pöördeid, nihkeid või värvimuutusi.
• Sünteetilised andmed: Kui teil on väike andmekogum, saate mõnikord genereerida uusi, realistlikke andmepunkte, valides jaotustest, mis modelleerivad teie olemasolevaid andmeid, aidates vältida üleküllastumist.
• Regulariseerimine: Tehnikaid nagu Dropout deaktiveerivad treenimise ajal juhuslikult osa neuroneid, et muuta võrk vastupidavamaks.

A/B testimine ja statistiline järeldus

Oletame, et käivitate A/B testi ja leiate, et teie uuel veebisaidi kujundusel on 5% kõrgem konversioonimäär. Kas see on tõeline paranemine või lihtsalt juhuslik õnn? Saate simulatsiooni abil teada saada. Luues kaks binoomjaotust sama aluseks oleva konversioonimääraga, saate simuleerida tuhandeid A/B teste, et näha, kui sageli esineb 5% või suurem erinevus juhuslikult. See aitab luua intuitsiooni selliste mõistete nagu p-väärtused ja statistiline olulisus.

Parimad tavad juhuslikuks valimiseks oma projektides

Nende tööriistade tõhusaks ja professionaalseks kasutamiseks pidage meeles järgmisi parimaid tavasid:

1. Kasutage alati kaasaegset generaatorit: Alustage oma skripte käsuga `rng = np.random.default_rng()`. Vältige uues koodis pärandfunktsioone `np.random.*`.
2. Seeme reprodutseeritavuse tagamiseks: Iga analüüsi, eksperimendi või aruande puhul külvake oma generaator (`np.random.default_rng(seed=...)`). See on usaldusväärse ja kontrollitava töö puhul mitte läbiräägitav.
3. Valige õige jaotus: Võtke aega, et mõelda reaalse maailma protsessile, mida te modelleerite. Kas see on seeria jah/ei katseid (binoom)? Kas see on aeg sündmuste vahel (eksponentsiaalne)? Kas see on mõõde, mis koonduvad keskmise ümber (normaalne)? Õige valik on sisuka simulatsiooni jaoks kriitiline.
4. Kasutage vektoriseerimist: NumPy on kiire, sest see teeb operatsioone korraga tervete massiividega. Genereerige kõik vajalikud juhuslikud arvud ühe kõnega (kasutades parameetrit `size`) pigem kui silmuses.
5. Visualiseerige, visualiseerige, visualiseerige: Pärast andmete genereerimist looge alati histogramm või muu graafik. See annab kiire kontrolli, et tagada andmete kuju vastavus jaotusele, millest te kavatsesite valimi võtta.

Kokkuvõte: juhuslikkusest arusaamani

Oleme rännanud seemnetega juhuslike arvude generaatori põhimõistest kuni mitmekesise statistiliste jaotuste komplekti valimi võtmise praktilise rakenduseni. NumPy `random` mooduli valdamine on rohkem kui tehniline harjutus; see on uue viisi avamine maailma mõistmiseks ja modelleerimiseks. See annab teile jõu simuleerida süsteeme, testida hüpoteese ja ehitada vastupidavamaid ja intelligentsemaid masinõppe mudeleid.

Võime genereerida andmeid, mis jäljendavad reaalsust, on kaasaegse andmeteadlase tööriistakomplektis põhiline oskus. Mõistes nende jaotuste omadusi ja NumPy pakutavaid võimsaid ja tõhusaid tööriistu, saate liikuda lihtsast andmeanalüüsist keeruka modelleerimise ja simulatsiooni juurde, muutes struktureeritud juhuslikkuse sügavaks arusaamiseks.